package com.yixia.system.service.impl.system;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yixia.common.core.domain.AjaxResult;
import com.yixia.common.core.domain.entity.SysDictData;
import com.yixia.common.core.domain.entity.SysDictType;
import com.yixia.common.utils.DictUtils;
import com.yixia.common.utils.StringUtils;
import com.yixia.system.mapper.system.SysDictDataMapper;
import com.yixia.system.mapper.system.SysDictTypeMapper;
import com.yixia.system.service.system.SysDictDataService;
import com.yixia.system.service.system.SysDictTypeService;
import com.yixia.common.constant.UserConstants;
import com.yixia.common.exception.ServiceException;

import com.yixia.common.utils.page.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
* @author 35038
* @description 针对表【sys_dict_type(字典类型表)】的数据库操作Service实现
* @createDate 2023-07-18 10:36:39
*/
@Service
public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType>
    implements SysDictTypeService {


    @Autowired
    private SysDictDataService dictDataService;


    @Autowired
    private SysDictTypeMapper dictTypeMapper;


    @Autowired
    private SysDictDataMapper dictDataMapper;

    /**
     * 分页查询
     * @param pageBean
     * @param dictType
     * @return
     */
    @Override
    public AjaxResult selectDictDataPage(PageBean pageBean, SysDictType dictType) {

        /*1、创建查询条件*/
        LambdaQueryWrapper<SysDictType> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(StringUtils.isNotEmpty(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
                    .eq(StringUtils.isNotEmpty(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
                    .like(StringUtils.isNotEmpty(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType());
        /*进行时间的查询*/
        queryWrapper.gt( StringUtils.isNotEmpty(dictType.getBeginTime()), SysDictType::getCreateTime, dictType.getBeginTime())
                    .lt(StringUtils.isNotEmpty(dictType.getEndTime()),SysDictType::getCreateTime, dictType.getEndTime());

        /*3.创建查询的page*/
        Page<SysDictType> page = new Page<>(pageBean.getPageNum(), pageBean.getPageSize());

        /*4.进行分页查询*/
        Page<SysDictType> pageResult = this.page(page, queryWrapper);

        AjaxResult ajax = AjaxResult.success();
        ajax.put("data", pageResult.getRecords());
        ajax.put("total", pageResult.getTotal());/*总记录数*/
        return ajax;
    }

    /**
     * 根据id来查询字典的详细信息
     * @param dictId
     * @return
     */
    @Override
    public SysDictType selectDictTypeById(Long dictId) {
        return dictTypeMapper.selectById(dictId);
    }

    /**
     * 新增保存字典类型信息
     *
     * @param dict 字典类型信息
     * @return 结果
     */
    @Override
    public boolean insertDictType(SysDictType dict) {

        boolean save = this.save(dict);
        if(save){
            //将其缓存到redis中
            DictUtils.setDictCache(dict.getDictType(), null);
        }

        return save;
    }

    /**
     * 校验字典类型称是否唯一
     *
     * @param dictType 字典类型
     * @return 结果
     */
    @Override
    public boolean checkDictTypeUnique(SysDictType dictType) {

        //1、获取到该字典的id
        Long dictId = StringUtils.isNull(dictType.getDictId()) ? -1L : dictType.getDictId();
        //2、根据dict_type进行查询
        LambdaQueryWrapper<SysDictType> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysDictType::getDictType, dictType.getDictType());
        SysDictType dictInfo = this.getOne(queryWrapper);
        //3、如果dictInfo存在或者查找到的Id与要添加的Id不相等则不能添加或者修改，第二个条天用来判断是否可以修改
        if (StringUtils.isNotNull(dictInfo) && dictInfo.getDictId().longValue() != dictId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }


    /**
     * 修改字典信息
     * @param dict
     * @return
     */
    @Override
    public boolean updateDictType(SysDictType dict) {
        //1.先获取旧的字典类型信息
        SysDictType oldDict = this.selectDictTypeById(dict.getDictId());
        //2.在同步修改data中的数据
        LambdaUpdateWrapper<SysDictData> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(SysDictData::getDictType, oldDict.getDictType());/*先根据类型查找到对应的数据信息*/
        updateWrapper.set(SysDictData::getDictType, dict.getDictType());/*将其设置为新的数据类型*/
        boolean update = dictDataService.update(updateWrapper);

        /*3.对type中对应的数据进行修改*/
        int row = dictTypeMapper.updateById(dict);
        if(row > 0){
            //类型名称被修改成功了
            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
            DictUtils.setDictCache(dict.getDictType(), dictDatas);
        }
        return row > 0;
    }

    /**
     * 根据id删除字典类型可以进行批量删除
     * @param dictIds
     */
    @Override
    public void deleteDictTypeByIds(Long[] dictIds) {
        for (Long dictId : dictIds)
        {
            //1.先根据id获取SysDictType类型信息
            SysDictType dictType = selectDictTypeById(dictId);
            //2.查询对应的数据信息，如果存在对应的数据信息则不可以进行删除
            if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0)
            {
                throw new ServiceException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
            }
            //3.进行删除操作
            dictTypeMapper.deleteDictTypeById(dictId);
            //4.删除redis中的缓存
            DictUtils.removeDictCache(dictType.getDictType());
        }
    }

    @Override
    public List<SysDictType> selectDictTypeAll() {
        return this.list();
    }


    /**
     * 根据字典类型查询字典数据
     * @param dictType
     * @return
     */
    @Override
    public List<SysDictData> selectDictDataByType(String dictType) {
        List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
        if (StringUtils.isNotEmpty(dictDatas))
        {
            return dictDatas;
        }
        dictDatas = dictDataMapper.selectDictDataByType(dictType);
        if (StringUtils.isNotEmpty(dictDatas))
        {
            DictUtils.setDictCache(dictType, dictDatas);
            return dictDatas;
        }
        return null;
    }


    /**
     * 重置字典缓存数据
     */
    @Override
    public void resetDictCache() {
        clearDictCache();
        loadingDictCache();
    }


    /**
     * 加载字典缓存数据
     */
    @Override
    public void loadingDictCache()
    {
        SysDictData dictData = new SysDictData();
        dictData.setStatus("0");
        Map<String, List<SysDictData>> dictDataMap = dictDataMapper.selectDictDataList(dictData).stream().collect(Collectors.groupingBy(SysDictData::getDictType));
        for (Map.Entry<String, List<SysDictData>> entry : dictDataMap.entrySet())
        {
            DictUtils.setDictCache(entry.getKey(), entry.getValue().stream().sorted(Comparator.comparing(SysDictData::getDictSort)).collect(Collectors.toList()));
        }
    }

    /**
     * 清空字典缓存数据
     */
    @Override
    public void clearDictCache()
    {
        DictUtils.clearDictCache();
    }
}




